MacTech 1 to 12/MacTech-vol-1-12.toast/Source/MacTech® Magazine/Volume 07 - 1991/07.08 Aug 91/Modeless SF Source/CStarterApp.p

Text File | 1991-01-13 | 6.9 KB | 291 lines | [TEXT/PJMM]

{****************************************************}
{}
{        CStarterApp.p                                                                    }
{}
{        Application methods for a typical application.                                    }
{}
{        Copyright © 1989, Symantec Corporation.  All rights reserved.            }
{}
{****************************************************}


UNIT CStarterApp;

INTERFACE

USES
    TCL, CSFDialogs, StarterIntf;

IMPLEMENTATION


{**}
{ * IStarterApp}
{ *}
{ *    Initialize the application. Your initialization method should}
{ *    at least call the inherited method. If your application class}
{ *    defines its own instance variables or global variables, this}
{ *    is a good place to initialize them.}
{ *}
{ **}

PROCEDURE CStarterApp.IStarterApp;

    BEGIN
        ICSFApplication(4, 20480, 2048);

        { The parameters to IApplication are the number of times to call MoreMasters,    }
        { the number of bytes of heap space to reserve for monitoring                        }
        { low memory situations, and the credit limit for memory requests.                }
        {   Four (4) is a reasonable number of MoreMasters calls,                            }
        { but you should determine a good number for your application                        }
        { by observing the heap using Lightsbug,                                                }
        { TMON, or Macsbug. Set this parameter to zero, give your                            }
        { program a rigorous work-out, then look at the heap and count                        }
        { how many master pointer blocks have been allocated. Master                        }
        { pointer blocks are nonrelocatable and have a size of $100                            }
        { (hex). You should call MoreMasters at least this many                                }
        { times -- add a few extra just to be safe. The purpose of all                        }
        { this preflighting is to prevent heap fragmentation. You                                }
        { don't want the Memory Manager to call MoreMasters and                            }
        { create a nonrelocatable block in the middle of your heap. By                        }
        { calling MoreMasters at the very beginning of the program,                            }
        { you ensure that these blocks are allocated in a group at the                        }
        { bottom of the heap.                                                                        }
        {   The memory reserve is a safeguard for handling low memory                    }
        { conditions and is used by the GrowMemory method in                                }
        { CApplication (check there for more comments). In general,                            }
        { your program should never request a memory block greater                        }
        { than this reserve size without explicitly checking in                                }
        { advance whether there is enough free memory to satisfy the                        }
        { the request.                                                                                }
        {   The credit limit specifies a cut-off level for memory                                }
        { requests which can tap the memory reserve. Requests larger                        }
        { than this size will not use the memory reserve when the                            }
        { system pleads for more memory.                                                        }

    END;



{**}
{ * SetUpFileParameters}
{ *}
{ *    In this routine, you specify the kinds of files your}
{ *    application opens.}
{ *}
{ **}

PROCEDURE CStarterApp.SetUpFileParameters;

    BEGIN

        INHERITED SetUpFileParameters;    { Be sure to call the default method }

        {*}
{         **    sfNumTypes is the number of file types}
{         **    your application knows about.}
{         **    sfFileTypes[] is an array of file types.}
{         **    You can define up to 4 file types in}
{         **    sfFileTypes[].}
{         **}
{         *}

        sfNumTypes := 1;
        sfFileTypes[0] := 'TEXT';

        {*}
{         **    Although it's not an instance variable,}
{         **    this method is a good place to set the}
{         **    gSignature global variable. Set this global}
{         **    to your application's signature. You'll use it}
{         **    to create a file (see CFile.CreateNew).}
{         **}
{         *}

        gSignature := '????';
    END;



{**}
{ * SetUpMenus }
{ *}
{ * Set up menus which must be created at run time, such as a}
{ * Font menu. You can eliminate this method if your application}
{ * does not have any such menus.}
{ *}
{**}

PROCEDURE CStarterApp.SetUpMenus;
    BEGIN

        INHERITED SetUpMenus;            { Superclass takes care of adding        }
                                        {   menus specified in a MBAR id = 1    }
                                        {   resource                                }

        { Add your code for creating run-time menus here    }
    END;


{**}
{ * DoCommand}
{ *}
{ *    Your application will probably handle its own commands.}
{ *    Remember, the command numbers from 1-1023 are reserved.}
{ *    The file TCL.p contains all the predefined TCL commands.}
{ *}
{ *    Be sure to call the default method, so you can get}
{ *    the default behavior for standard commands.}
{ *}
{ **}

PROCEDURE CStarterApp.DoCommand (theCommand: longint);

    VAR
        aCSFGetDialog: CSFGetDialog;
        aCSFSaveDialog: CSFSaveDialog;

    BEGIN

        CASE theCommand OF

            CSFOpenCmd:
                BEGIN
                    New(aCSFGetDialog);
                    aCSFGetDialog.ICSFDialog
                END;

            CSFSaveCmd:
                BEGIN
                    New(aCSFSaveDialog);
                    aCSFSaveDialog.ICSFDialog
                END;

            OTHERWISE                                        { Invoke inherited method     }
                INHERITED DoCommand(theCommand);        { to handle other commands    }

        END;
    END;


{**}
{ *}
{ * UpdateMenus }
{ *}
{ *     Perform menu management tasks}
{ *}
{**}

PROCEDURE CStarterApp.UpdateMenus;
    BEGIN

        INHERITED UpdateMenus;            { Enable standard commands            }

        gBartender.EnableCmd(CSFOpenCmd);
        gBartender.EnableCmd(CSFSaveCmd);

        { Enable the commands handled by your Application class    }
    END;


{**}
{ * Exit}
{ *}
{ *    Chances are you won't need this method.}
{ *    This is the last chance your application gets to clean up}
{ *    things like temporary files before terminating.}
{ *}
{ **}

PROCEDURE CStarterApp.Exit;

    BEGIN
    { your exit handler here }
    END;


{**}
{ * CreateDocument}
{ *}
{ *    The user chose New from the File menu.}
{ *    In this method, you need to create a document and send it}
{ *    a NewFile message.}
{ *}
{ **}

PROCEDURE CStarterApp.CreateDocument;

    VAR
        theDocument: CStarterDoc;

    BEGIN

        new(theDocument);

        {*}
{         **    Send your document an initialization}
{         **    message. The first argument is the document's}
{         **    supervisor (the application). The second}
{         **    argument is TRUE if the document is printable.}
{         **}
{         *}

        theDocument.IStarterDoc(SELF, TRUE);

        {*}
{         **    Send the document a NewFile message.}
{         **    The document will open a window, and}
{         **    set up the heart of the application.}
{         **}
{         *}

        theDocument.NewFile;
    END;


{**}
{ * OpenDocument}
{ *}
{ *    The user chose Open… from the File menu.}
{ *    In this method you need to create a document}
{ *    and send it an OpenFile message.}
{ *}
{ *    The macSFReply is a good SFReply record that contains}
{ *    the name and vRefNum of the file the user chose to}
{ *    open.}
{ *}
{ **}

PROCEDURE CStarterApp.OpenDocument (macSFReply: SFReply);

    VAR
        theDocument: CStarterDoc;

    BEGIN

        new(theDocument);

        {*}
{         **    Send your document an initialization}
{         **    message. The first argument is the document's}
{         **    supervisor (the application). The second}
{         **    argument is TRUE if the document is printable.}
{         **}
{         *}

        theDocument.IStarterDoc(SELF, TRUE);

        {*}
{         **    Send the document an OpenFile message.}
{         **    The document will open a window, open}
{         **    the file specified in the macSFReply record,}
{         **    and display it in its window.}
{         **}
{         *}

        theDocument.OpenFile(macSFReply);
    END;


END.